PC for Alla 2005 May/PC för Alla 0505.iso/fullversioner/realsoft3d/data1.cab/Scripting/scripts/js/real/objects/r3subdiv.js

JavaScript | 2005-04-04 | 50.7 KB | 1,568 lines

// JavaScript wrapper for r3subdiv.h
// Auto generated file, do not modify by hand
// Copyright ⌐ 2004, Realsoft Graphics Oy

var R3_SUBDIV_H = 1;
include("real/objects/r3level.js")
include("real/objects/r3triset.js")


var R3CLID_SUBDIVISION = 1235;

var R3SDSMAXWEIGHT = 100;
var R3SDSMINWEIGHT = 0.001;
var R3SDS_MAXMATERIALSPERFACE = 20;



// Description: adds a face between n selected vertices

R3SUBDIVM_ADDFACE = 1235000;

function mR3SUBDIVM_ADDFACE() {
  DoA(this.r3obj, 1235000, 0, R3TID_INTEGER, 0);
}

// Description: merges selected vertices

R3SUBDIVM_MERGEVERTICES = 1235001;

function mR3SUBDIVM_MERGEVERTICES() {
  DoA(this.r3obj, 1235001, 0, R3TID_INTEGER, 0);
}

// Description: subdivides the whole object
// p3: Integer, number of iterations, >0

R3SUBDIVM_SUBDIVIDE = 1235002;

function mR3SUBDIVM_SUBDIVIDE(p3) {
  DoA(this.r3obj, 1235002, p3, R3TID_INTEGER, 0);
}

// Description: subdivides selected faces

R3SUBDIVM_SUBDIVIDEFACE = 1235003;

function mR3SUBDIVM_SUBDIVIDEFACE() {
  DoA(this.r3obj, 1235003, 0, R3TID_INTEGER, 0);
}

// Description: extrudes selected edges or faces
// Returns: Boolean, true if succeeded
// p1: Number, extrusion depth
// p2: Integer, action, see r3subdivisionaction below
// p3: Tag[], tag list containing R3SUBDIVA_ExtrudeRegionOpt, R3SUBDIVA_ExtrudeNormalOpt, R3SUBDIVA_ExtrudeLeaveFloor, R3SUBDIVA_ExtrudeSectionCount.

R3SUBDIVM_EXTRUDE = 1235004;

function mR3SUBDIVM_EXTRUDE(p1, p2, p3) {
  return   Do3(this.r3obj, 1235004, p1, R3TID_FLOAT, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: return the number of edges of the face that has the most edges.
// Returns: Integer, max edgecount

R3SUBDIVM_GETMAXEDGESPERFACE = 1235005;

function mR3SUBDIVM_GETMAXEDGESPERFACE() {
  return   DoA(this.r3obj, 1235005, 0, R3TID_INTEGER, 0);
}

// Description: splits the selected edges.

R3SUBDIVM_SPLITEDGE = 1235006;

function mR3SUBDIVM_SPLITEDGE() {
  DoA(this.r3obj, 1235006, 0, R3TID_INTEGER, 0);
}

// Description: divides face between two selected vertices.

R3SUBDIVM_DIVIDEFACE = 1235007;

function mR3SUBDIVM_DIVIDEFACE() {
  DoA(this.r3obj, 1235007, 0, R3TID_INTEGER, 0);
}

// Description: merges selected faces.

R3SUBDIVM_MERGEFACES = 1235008;

function mR3SUBDIVM_MERGEFACES() {
  DoA(this.r3obj, 1235008, 0, R3TID_INTEGER, 0);
}

// Description: Set given UV coordinates for the selected vertices

R3SUBDIVM_SETUV = 1235009;

function mR3SUBDIVM_SETUV() {
  DoA(this.r3obj, 1235009, 0, R3TID_INTEGER, 0);
}

// Description: Fetch the uv coordinates of the given vertex
// Returns: Boolean, true if succeeded
// p1: r3Vect, uv coordinates
// p3: Integer, index of the vertex

R3SUBDIVM_GETUV = 1235010;

function mR3SUBDIVM_GETUV(p1, p3) {
  return   DoA2(this.r3obj, 1235010, p1, R3TID_VECTOR, 0, p3, R3TID_INTEGER, 0);
}

// Description: separates the selected edges.

R3SUBDIVM_SEPARATEFACES = 1235011;

function mR3SUBDIVM_SEPARATEFACES() {
  DoA(this.r3obj, 1235011, 0, R3TID_INTEGER, 0);
}

// Description: creates an empty face (no vertices)

R3SUBDIVM_NEWFACE = 1235013;

function mR3SUBDIVM_NEWFACE() {
  DoA(this.r3obj, 1235013, 0, R3TID_INTEGER, 0);
}

// Description: deletes a face
// p3: Integer, face index

R3SUBDIVM_DELFACE = 1235014;

function mR3SUBDIVM_DELFACE(p3) {
  DoA(this.r3obj, 1235014, p3, R3TID_INTEGER, 0);
}

// Description: modifies the specified face (index in p3) to contain selected vertices
// p3: Integer, face index

R3SUBDIVM_UPDATEFACE = 1235015;

function mR3SUBDIVM_UPDATEFACE(p3) {
  DoA(this.r3obj, 1235015, p3, R3TID_INTEGER, 0);
}

// Description: melts faces together by removing separating edges. * Action depends on select resolution.

R3SUBDIVM_MELT = 1235016;

function mR3SUBDIVM_MELT() {
  DoA(this.r3obj, 1235016, 0, R3TID_INTEGER, 0);
}

// Description: extrudes the selected vertices
// p1: Number, percentage of subdivide (distance from original vertex along the edge)
// p3: Number, amount of extrude

R3SUBDIVM_EXTRUDEVERTEX = 1235017;

function mR3SUBDIVM_EXTRUDEVERTEX(p1, p3) {
  DoA2(this.r3obj, 1235017, p1, R3TID_FLOAT, 0, p3, R3TID_FLOAT, 0);
}

// Description: Merges the selected subdivision objects into one.
// p1: Boolean, save faceids
// p3: Object[], null terminated array of objects to be merged

R3SUBDIVM_MERGEOBJECTS = 1235018;

function mR3SUBDIVM_MERGEOBJECTS(p1, p3) {
  DoA2(this.r3obj, 1235018, p1, R3TID_BOOLEAN, 0, p3, R3TID_OBJECT, R3TNF_ARRAY);
}

// Description: Hides the selected faces.

R3SUBDIVM_HIDESELECTEDFACES = 1235019;

function mR3SUBDIVM_HIDESELECTEDFACES() {
  DoA(this.r3obj, 1235019, 0, R3TID_INTEGER, 0);
}

// Description: Un-hides all faces.

R3SUBDIVM_SHOWALLFACES = 1235020;

function mR3SUBDIVM_SHOWALLFACES() {
  DoA(this.r3obj, 1235020, 0, R3TID_INTEGER, 0);
}

// Description: Connects two selected edges with a new face.

R3SUBDIVM_CONNECTEDGES = 1235021;

function mR3SUBDIVM_CONNECTEDGES() {
  DoA(this.r3obj, 1235021, 0, R3TID_INTEGER, 0);
}

// Description: Transforms selected faces.
// p1: r3Vect, the components are used to define: r - amount of rotation s - scale
//      factor t - amount of translation
// p2: Integer, normal option, either R3SDSTRANSFFACENORMALOPT_FACE or R3SDSTRANSFFACENORMALOPT_GROUP
// p3: Tag[], tag list containing R3SUBDIVA_TransformCenter, R3SUBDIVA_TransformNormal, R3SUBDIVA_ScaleDirection

R3SUBDIVM_TRANSFORMFACE = 1235022;

function mR3SUBDIVM_TRANSFORMFACE(p1, p2, p3) {
  Do3(this.r3obj, 1235022, p1, R3TID_VECTOR, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Copies the the faces and connects the edges.

R3SUBDIVM_DUPLICATEANDCONNEC = 1235023;

function mR3SUBDIVM_DUPLICATEANDCONNEC() {
  DoA(this.r3obj, 1235023, 0, R3TID_INTEGER, 0);
}

// Description: Bevels selected vertices
// p3: Number, percentage of bevel (distance from original vertex along the edge)

R3SUBDIVM_BEVELVERTICES = 1235024;

function mR3SUBDIVM_BEVELVERTICES(p3) {
  DoA(this.r3obj, 1235024, p3, R3TID_FLOAT, 0);
}

// Description: Bevels selected edges
// p3: Number, percentage of bevel (distance from original vertex along the edge)

R3SUBDIVM_BEVELEDGES = 1235025;

function mR3SUBDIVM_BEVELEDGES(p3) {
  DoA(this.r3obj, 1235025, p3, R3TID_FLOAT, 0);
}

// Description: Converts a face to trisets
// Returns: Integer, number of resulting triset faces
// p2: r3Vect, vertices
// p3: Tag[], attributes R3SUBDIVA_TrisetFace, R3SUBDIVA_KeepAllPoints, R3SUBDIVA_UVCoords, R3SUBDIVA_OriginalIndices.

R3SUBDIVCM_FACETOTRISETS = 1235026;

function mR3SUBDIVCM_FACETOTRISETS(p2, p3) {
  return   Do3(this.r3obj, 1235026, 0, R3TID_INTEGER, 0, p2, R3TID_VECTOR, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Flips the normals of the selected faces by changing the    * order in which the
//      vertices are referenced.
// p3: Boolean, regions flag. If set, flips opposing faces in each selection region.

R3SUBDIVM_FLIPSELECTEDFACES = 1235027;

function mR3SUBDIVM_FLIPSELECTEDFACES(p3) {
  DoA(this.r3obj, 1235027, p3, R3TID_BOOLEAN, 0);
}

// Description: Add new uvw channel
// Returns: Object, NULL if failed
// p3: Tag[], R3SUBDIVA_WrapU, R3SUBDIVA_WrapV, R3SUBDIVA_UVWrapMin, R3SUBDIVA_UVWrapMax, R3SUBDIVA_UVCoords

R3SUBDIVM_ADDUVWCHANNEL = 1235028;

function mR3SUBDIVM_ADDUVWCHANNEL(p3) {
  return   Do(this.r3obj, 1235028, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Delete uvw channel
// Returns: Boolean, NULL if channel was not found
// p3: String, name of the channel to be deleted

R3SUBDIVM_DELUVWCHANNEL = 1235029;

function mR3SUBDIVM_DELUVWCHANNEL(p3) {
  return   DoA(this.r3obj, 1235029, p3, R3TID_STRING, 0);
}

// Description: merges selected edges (only if topology does not change).

R3SUBDIVM_MERGEEDGES = 1235030;

function mR3SUBDIVM_MERGEEDGES() {
  DoA(this.r3obj, 1235030, 0, R3TID_INTEGER, 0);
}

// Description: destroys faces.
// p3: Boolean, if TRUE vertices that become orphan are not deleted.

R3SUBDIVM_DESTROYFACE = 1235031;

function mR3SUBDIVM_DESTROYFACE(p3) {
  DoA(this.r3obj, 1235031, p3, R3TID_BOOLEAN, 0);
}

// Description: Merges the selected subdivision objects into one.    * All vertices and faces of the first
//      selected object    * and selected vertices and selected faces of the other * selected objects are
//      merged.
// p3: Object[], null terminated array of objects to be merged

R3SUBDIVM_MERGEOBJECTSSELECT = 1235032;

function mR3SUBDIVM_MERGEOBJECTSSELECT(p3) {
  DoA(this.r3obj, 1235032, p3, R3TID_OBJECT, R3TNF_ARRAY);
}

// Description: Converts polygonal SDS to trisets.
// Returns: Boolean, TRUE if successfull
// p3: Integer[], returns the number of faces.

R3SUBDIVM_POLYGONALTOTRISETS = 1235033;

function mR3SUBDIVM_POLYGONALTOTRISETS(p3) {
  return   DoA(this.r3obj, 1235033, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Converts smooth SDS to trisets.
// Returns: Boolean, TRUE if successfull
// p3: Integer[], returns the number of faces.

R3SUBDIVM_SMOOTHTOTRISETS = 1235034;

function mR3SUBDIVM_SMOOTHTOTRISETS(p3) {
  return   DoA(this.r3obj, 1235034, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Divides the selected faces to triangles. Uses the face center to divide.
// Returns: Boolean, TRUE if successfull
// p3: Boolean, if TRUE processes all faces

R3SUBDIVM_SELECTEDFACESTOTRI = 1235035;

function mR3SUBDIVM_SELECTEDFACESTOTRI(p3) {
  return   DoA(this.r3obj, 1235035, p3, R3TID_BOOLEAN, 0);
}

// Description: Divides the selected faces to quads. Uses the face center to divide.
// Returns: Boolean, TRUE if successfull
// p3: Boolean, if TRUE processes all faces

R3SUBDIVM_SELECTEDFACESTOQUA = 1235036;

function mR3SUBDIVM_SELECTEDFACESTOQUA(p3) {
  return   DoA(this.r3obj, 1235036, p3, R3TID_BOOLEAN, 0);
}

// Description: If you have to manipulate the face array directly, call this to inform the
//      sds object.

R3SUBDIVM_FACESCHANGEDFROMOU = 1235037;

function mR3SUBDIVM_FACESCHANGEDFROMOU() {
  DoA(this.r3obj, 1235037, 0, R3TID_INTEGER, 0);
}

// Description: Make tunnel between selected faces
// Returns: Boolean, TRUE if successfull

R3SUBDIVM_MAKETUNNEL = 1235038;

function mR3SUBDIVM_MAKETUNNEL() {
  return   DoA(this.r3obj, 1235038, 0, R3TID_INTEGER, 0);
}

// Description: Subdivides selected regions.
// Returns: Boolean, TRUE if successfull

R3SUBDIVM_SUBDIVIDELOCALLY = 1235039;

function mR3SUBDIVM_SUBDIVIDELOCALLY() {
  return   DoA(this.r3obj, 1235039, 0, R3TID_INTEGER, 0);
}

// Description: Calculates vertex normals.
// Returns: Boolean, TRUE if successfull
// p1: Boolean, if TRUE the normal lengths will be scaled according to the * face sizes,
//      otherwise the normals will be normalized * (length 1.0).
// p3: r3Vect, the vertex normals are returned here

R3SUBDIVM_CALCULATEVERTEXNOR = 1235040;

function mR3SUBDIVM_CALCULATEVERTEXNOR(p1, p3) {
  return   DoA2(this.r3obj, 1235040, p1, R3TID_BOOLEAN, 0, p3, R3TID_VECTOR, 0);
}

// Description: Moves the selected faces along vertex normals.
// p1: Number, amount of translation
// p3: r3Vect, direction

R3SUBDIVM_MOVEVERTEXONNORMAL = 1235041;

function mR3SUBDIVM_MOVEVERTEXONNORMAL(p1, p3) {
  DoA2(this.r3obj, 1235041, p1, R3TID_FLOAT, 0, p3, R3TID_VECTOR, 0);
}

// Description: Invalidates internal smooth object used for evaluating the * SDS geometry

R3SUBDIVM_INVALIDATESMOOTHOB = 1235042;

function mR3SUBDIVM_INVALIDATESMOOTHOB() {
  DoA(this.r3obj, 1235042, 0, R3TID_INTEGER, 0);
}

// Description: Calculates edge centers and normals.
// Returns: Boolean, TRUE if successfull
// p1: r3Vect, the edge centers are returned here
// p2: Boolean, if TRUE the normal lengths will be scaled according to the * edge lengths,
//      otherwise the normals will be normalized * (length 1.0).
// p3: r3Vect, the edge normals are returned here

R3SUBDIVM_CALCULATEEDGECENTE = 1235043;

function mR3SUBDIVM_CALCULATEEDGECENTE(p1, p2, p3) {
  return   DoA3(this.r3obj, 1235043, p1, R3TID_VECTOR, 0, p2, R3TID_BOOLEAN, 0, p3, R3TID_VECTOR, 0);
}

// Description: Transforms selected edges.
// p1: r3Vect, the components are used to define: r - amount of rotation s - scale
//      factor t - amount of translation
// p2: Integer, normal option, either R3SDSTRANSFFACENORMALOPT_FACE or R3SDSTRANSFFACENORMALOPT_GROUP
// p3: Tag[], tag list containing R3SUBDIVA_TransformCenter, R3SUBDIVA_TransformNormal

R3SUBDIVM_TRANSFORMEDGE = 1235044;

function mR3SUBDIVM_TRANSFORMEDGE(p1, p2, p3) {
  Do3(this.r3obj, 1235044, p1, R3TID_VECTOR, 0, p2, R3TID_INTEGER, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Selects faces that have edges where more than two faces connect.

R3SUBDIVM_SELECTINVALIDFACES = 1235045;

function mR3SUBDIVM_SELECTINVALIDFACES() {
  DoA(this.r3obj, 1235045, 0, R3TID_INTEGER, 0);
}

// Description: Smoothens the normals of the selected vertices,

R3SUBDIVM_SMOOTHENVERTEXNORM = 1235046;

function mR3SUBDIVM_SMOOTHENVERTEXNORM() {
  DoA(this.r3obj, 1235046, 0, R3TID_INTEGER, 0);
}

// Description: Smoothens the normals of the selected vertices,

R3SUBDIVM_FLATTENVERTEXNORMA = 1235047;

function mR3SUBDIVM_FLATTENVERTEXNORMA() {
  DoA(this.r3obj, 1235047, 0, R3TID_INTEGER, 0);
}


R3SUBDIVM_SETPOINTWISEVALUE = 1235048;

function mR3SUBDIVM_SETPOINTWISEVALUE() {
  DoA(this.r3obj, 1235048, 0, R3TID_INTEGER, 0);
}


R3SUBDIVM_GETPOINTWISEVALUE = 1235049;

function mR3SUBDIVM_GETPOINTWISEVALUE() {
  DoA(this.r3obj, 1235049, 0, R3TID_INTEGER, 0);
}

// Description: add pointwise attribute

R3SUBDIVM_ADDPOINTWISEATTRIB = 1235050;

function mR3SUBDIVM_ADDPOINTWISEATTRIB() {
  DoA(this.r3obj, 1235050, 0, R3TID_INTEGER, 0);
}

// Description: remove pointwise attribute

R3SUBDIVM_REMOVEPOINTWISEATT = 1235051;

function mR3SUBDIVM_REMOVEPOINTWISEATT() {
  DoA(this.r3obj, 1235051, 0, R3TID_INTEGER, 0);
}

// Returns: Number, weights

R3SUBDIVM_GETWEIGHTS = 1235052;

function mR3SUBDIVM_GETWEIGHTS() {
  return   DoA(this.r3obj, 1235052, 0, R3TID_INTEGER, 0);
}

// Description: Translate the weights of the selected vertices.
// p1: Boolean, if true, p3 translates the current weight. Otherwise p3 is taken as new absolute
//      weight for the selected vertices.
// p3: Number, abs/rel weight

R3SUBDIVM_CHANGEWEIGHTS = 1235053;

function mR3SUBDIVM_CHANGEWEIGHTS(p1, p3) {
  DoA2(this.r3obj, 1235053, p1, R3TID_BOOLEAN, 0, p3, R3TID_FLOAT, 0);
}

// Description: Converts selected triangular faces to quads.

R3SUBDIVM_TRIANGLESTOQUADS = 1235055;

function mR3SUBDIVM_TRIANGLESTOQUADS() {
  DoA(this.r3obj, 1235055, 0, R3TID_INTEGER, 0);
}

// p3: Integer, iterations

R3SUBDIVM_INVERT = 1235056;

function mR3SUBDIVM_INVERT(p3) {
  DoA(this.r3obj, 1235056, p3, R3TID_INTEGER, 0);
}

// Description: Describes the surface geometry of SDS object by repeated calls to given hook.    * The
//      actions are the same as when sending PRIMM_RENDERSURFACES to the sds object. * The patches
//      are described using the tags of the selected surface type. * See r3sbs3.h, r3sbili.h and
//      r3stri.h (also r3frsurf.h for info about pointwise attributes). * For example, if render type is
//      smoothen to triangles, hook is called as * (*Hook)(R3CLID_STRIANGLE, hookdata, tags), * tags = R3STRIA_Points,
//      vertexarrayof3, * R3STRIA_Normals, normalarrayof3, * R3FRSURFA_PointAttrs, pa_as_defined_in_r3frsurf_h, * R3TAG_END); *
// p3: Object, any appropriate callback context data

R3SUBDIVM_RENDERPATCHES = 1235057;

function mR3SUBDIVM_RENDERPATCHES(p3) {
  DoA(this.r3obj, 1235057, p3, R3TID_OBJECT, 0);
}

// Description: Sets the sharpness of the selected edges
// p3: Integer, sharpness (0 == rounded, 1 == semisharp, 2 == sharp, * 3 == free,
//      defined by edge rounding

R3SUBDIVM_SETSELECTEDEDGESHA = 1235058;

function mR3SUBDIVM_SETSELECTEDEDGESHA(p3) {
  DoA(this.r3obj, 1235058, p3, R3TID_INTEGER, 0);
}

// Description: Gets the sharpness of the specified edge
// p1: Integer, edge index
// p3: Integer[], returns sharpness

R3SUBDIVM_GETEDGESHARPNESS = 1235059;

function mR3SUBDIVM_GETEDGESHARPNESS(p1, p3) {
  DoA2(this.r3obj, 1235059, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Sets the sharpness of the selected vertices
// p3: Integer, sharpness (0 == rounded, 1 == semisharp, 2 == sharp, 3 == free

R3SUBDIVM_SETSELECTEDVERTEXS = 1235060;

function mR3SUBDIVM_SETSELECTEDVERTEXS(p3) {
  DoA(this.r3obj, 1235060, p3, R3TID_INTEGER, 0);
}

// Description: Gets the sharpness of the specified vertex
// p1: Integer, vertex index
// p3: Integer[], returns sharpness

R3SUBDIVM_GETVERTEXSHARPNESS = 1235061;

function mR3SUBDIVM_GETVERTEXSHARPNESS(p1, p3) {
  DoA2(this.r3obj, 1235061, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Creates/frees list of unique edges.
// p3: r3List, list containing unique edges

R3SUBDIVM_FREEEDGELIST = 1235063;

function mR3SUBDIVM_FREEEDGELIST(p3) {
  DoA(this.r3obj, 1235063, p3, R3TID_LIST, 0);
}

// Description: Sets the rounding of the selected edges
// p1: Boolean, cumulative
// p3: Number, rounding

R3SUBDIVM_SETSELECTEDEDGEROU = 1235064;

function mR3SUBDIVM_SETSELECTEDEDGEROU(p1, p3) {
  DoA2(this.r3obj, 1235064, p1, R3TID_BOOLEAN, 0, p3, R3TID_FLOAT, 0);
}

// Description: Gets the rounding of the specified edge
// p1: Integer, edge index
// p3: Number, returns rounding

R3SUBDIVM_GETEDGEROUNDING = 1235065;

function mR3SUBDIVM_GETEDGEROUNDING(p1, p3) {
  DoA2(this.r3obj, 1235065, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Joins edges of separate faces when the edges are near enough each other
// p3: Number, distance

R3SUBDIVM_JOINFACES = 1235066;

function mR3SUBDIVM_JOINFACES(p3) {
  DoA(this.r3obj, 1235066, p3, R3TID_FLOAT, 0);
}

// Description: Returns pointwise channel data
// Returns: Object, channel data

R3SUBDIVM_GETPOINTWISECHANNE = 1235067;

function mR3SUBDIVM_GETPOINTWISECHANNE() {
  return   DoA(this.r3obj, 1235067, 0, R3TID_INTEGER, 0);
}

// Description: Fetch orientation of the given face.
// p1: Integer, index of the face
// p3: r3Coordsys, space of the face

R3SUBDIVM_GETFACESPACE = 1235070;

function mR3SUBDIVM_GETFACESPACE(p1, p3) {
  DoA2(this.r3obj, 1235070, p1, R3TID_INTEGER, 0, p3, R3TID_COORDSYS, 0);
}

// Description: Fetch uvw channel attributes
// Returns: Boolean, true if uvw channel was found
// p1: Integer, channelname
// p3: Tag[], R3SUBDIVA_WrapU, R3SUBDIVA_WrapV, R3SUBDIVA_UVWrapMin, R3SUBDIVA_UVWrapMax, R3SUBDIVA_UVCoords

R3SUBDIVM_GETUVWATTRS = 1235071;

function mR3SUBDIVM_GETUVWATTRS(p1, p3) {
  return   Do2(this.r3obj, 1235071, p1, R3TID_BYTE, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Fetch custom channel attributes. R3SUBDIVA_ChannelData points to an array of channel values associated with
//      control points. ChannelItemSize specifies the size of items in R3FLOAT's.
// Returns: Boolean, true if the given channel was found
// p1: Integer, channelname
// p3: Tag[], R3SUBDIVA_ChannelData, R3SUBDIVA_ChannelUniqueId, R3SUBDIVA_ChannelType, R3SUBDIVA_ChannelItemSize

R3SUBDIVM_GETCHANNELATTRS = 1235072;

function mR3SUBDIVM_GETCHANNELATTRS(p1, p3) {
  return   Do2(this.r3obj, 1235072, p1, R3TID_BYTE, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}


R3SUBDIVM_ALLOCPOINTS = 1235076;

function mR3SUBDIVM_ALLOCPOINTS() {
  DoA(this.r3obj, 1235076, 0, R3TID_INTEGER, 0);
}

// Description: Copies a vertex to another vertex.
// p1: Integer, to
// p3: Integer, from

R3SUBDIVM_ASSIGNVERTEX = 1235077;

function mR3SUBDIVM_ASSIGNVERTEX(p1, p3) {
  DoA2(this.r3obj, 1235077, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Creates a face to given vertices.
// p1: Integer, vertex count
// p3: Integer[], vertex indices

R3SUBDIVM_MAKEFACE = 1235079;

function mR3SUBDIVM_MAKEFACE(p1, p3) {
  DoA2(this.r3obj, 1235079, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Attach material to selected faces.
// p3: String, material name

R3SUBDIVM_ATTACHMATERIALTOSE = 1235080;

function mR3SUBDIVM_ATTACHMATERIALTOSE(p3) {
  DoA(this.r3obj, 1235080, p3, R3TID_STRING, 0);
}

// Description: Detach material from selected faces.
// p3: String, material name

R3SUBDIVM_DETACHMATERIALFROM = 1235081;

function mR3SUBDIVM_DETACHMATERIALFROM(p3) {
  DoA(this.r3obj, 1235081, p3, R3TID_STRING, 0);
}

// Description: Returns a pointer to face material list containing R3FACEMATERIAL structures or a NULL pointer
//      if no materials are defined for the face.
// p3: Integer, face index

R3SUBDIVM_GETFACEMATERIALLIS = 1235082;

function mR3SUBDIVM_GETFACEMATERIALLIS(p3) {
  DoA(this.r3obj, 1235082, p3, R3TID_INTEGER, 0);
}

// Description: private

R3SUBDIVM_OPTIMIZEFACES = 1235083;

function mR3SUBDIVM_OPTIMIZEFACES() {
  DoA(this.r3obj, 1235083, 0, R3TID_INTEGER, 0);
}

// p1: Integer, face index
// p2: Integer, index in face
// p3: Integer, index to vertices

R3SUBDIVM_INSERTVERTEXTOFACE = 1235089;

function mR3SUBDIVM_INSERTVERTEXTOFACE(p1, p2, p3) {
  DoA3(this.r3obj, 1235089, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Remove the given vertex from the specified face.
// p1: Integer, face index
// p2: Integer
// p3: Integer, index in face

R3SUBDIVM_REMOVEVERTEXFROMFA = 1235090;

function mR3SUBDIVM_REMOVEVERTEXFROMFA(p1, p2, p3) {
  DoA3(this.r3obj, 1235090, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Shows/hides the selected faces in UV editors.

R3SUBDIVM_SETSELECTEDFACESUV = 1235091;

function mR3SUBDIVM_SETSELECTEDFACESUV() {
  DoA(this.r3obj, 1235091, 0, R3TID_INTEGER, 0);
}

// Description: Shows/hides all faces in UV editors.

R3SUBDIVM_SETALLFACESUVVISIB = 1235092;

function mR3SUBDIVM_SETALLFACESUVVISIB() {
  DoA(this.r3obj, 1235092, 0, R3TID_INTEGER, 0);
}

// Description: sets face material UVs for a face
// p1: Integer, face index
// p2: String, material name
// p3: r3Vect, array of UVs, one for each vertex of the face

R3SUBDIVM_SETFACEMATERIALUV = 1235093;

function mR3SUBDIVM_SETFACEMATERIALUV(p1, p2, p3) {
  DoA3(this.r3obj, 1235093, p1, R3TID_INTEGER, 0, p2, R3TID_STRING, 0, p3, R3TID_VECTOR, 0);
}

// Description: Detach material from all faces.
// p3: String, material name

R3SUBDIVM_DETACHMATERIALFROM = 1235094;

function mR3SUBDIVM_DETACHMATERIALFROM(p3) {
  DoA(this.r3obj, 1235094, p3, R3TID_STRING, 0);
}

// Description: Fetch the number of vertices in the given face.
// Returns: Integer, number of vertices
// p3: Integer, face index

R3SUBDIVM_GETVERTEXCOUNTOFFA = 1235095;

function mR3SUBDIVM_GETVERTEXCOUNTOFFA(p3) {
  return   DoA(this.r3obj, 1235095, p3, R3TID_INTEGER, 0);
}

// Description: Interpolates pointwise values for a vertex
// p1: Integer, index of the vertex for which to interpolate pointwise values
// p2: Number, interpolation factor
// p3: Tag[], tag list containing R3RA_P0, R3RA_P1 - the indices of the the vertices to interpolate
//      from

R3SUBDIVM_INTERPOLATEPOINTWI = 1235097;

function mR3SUBDIVM_INTERPOLATEPOINTWI(p1, p2, p3) {
  Do3(this.r3obj, 1235097, p1, R3TID_INTEGER, 0, p2, R3TID_FLOAT, 0, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Divides given faces between given vertices
// p1: Integer, number of groups consisting of a face index and a pair indices
// p2: Integer[], array of face indices
// p3: Integer[], array of vertex indices arranged in pairs

R3SUBDIVM_DIVIDEFACESBYINDIC = 1235098;

function mR3SUBDIVM_DIVIDEFACESBYINDIC(p1, p2, p3) {
  DoA3(this.r3obj, 1235098, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, R3TNF_ARRAY, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Calculates face centers and normals.
// Returns: Boolean, TRUE if successfull
// p1: r3Vect, the face centers are returned here
// p2: Integer, space
// p3: r3Vect, the face normals are returned here

R3SUBDIVM_CALCULATEFACECENTE = 1235099;

function mR3SUBDIVM_CALCULATEFACECENTE(p1, p2, p3) {
  return   DoA3(this.r3obj, 1235099, p1, R3TID_VECTOR, 0, p2, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Copies the the faces (does not connect the edges).

R3SUBDIVM_DUPLICATE = 1235100;

function mR3SUBDIVM_DUPLICATE() {
  DoA(this.r3obj, 1235100, 0, R3TID_INTEGER, 0);
}

// Description: Copies the selected parts of the SDS object into a new object.
// Returns: Object, sds object containing the selected parts

R3SUBDIVM_COPYSELECTED = 1235101;

function mR3SUBDIVM_COPYSELECTED() {
  return R3ToJS(  DoA(this.r3obj, 1235101, 0, R3TID_INTEGER, 0));
}

// Description: Set vertex count and vertex indices for the given face.
// Returns: Boolean, true if succeeded
// p1: Integer, index of the face to be defined
// p2: Integer, number of vertices
// p3: Integer[], array of vertex indices

R3SUBDIVM_SETFACE = 1235105;

function mR3SUBDIVM_SETFACE(p1, p2, p3) {
  return   DoA3(this.r3obj, 1235105, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Fill holes
// Returns: Boolean, true if succeeded
// p1: Boolean, selected, if set only holes in selected regions will be filled
// p3: Integer, maximum number of edges in a hole to fill

R3SUBDIVM_FILLHOLES = 1235106;

function mR3SUBDIVM_FILLHOLES(p1, p3) {
  return   DoA2(this.r3obj, 1235106, p1, R3TID_BOOLEAN, 0, p3, R3TID_INTEGER, 0);
}

// Description: Unwraps the current UV channel using the subdivision algorithm to the UV values.
// p3: Integer, subdivision iterations

R3SUBDIVM_UNWRAPUV = 1235107;

function mR3SUBDIVM_UNWRAPUV(p3) {
  DoA(this.r3obj, 1235107, p3, R3TID_INTEGER, 0);
}

// Description: Calculates default values for the current UV channel using sphere projection.

R3SUBDIVM_DEFAULTUV = 1235108;

function mR3SUBDIVM_DEFAULTUV() {
  DoA(this.r3obj, 1235108, 0, R3TID_INTEGER, 0);
}

// Description: Deletes selected vertices that are not connected to any face.

R3SUBDIVM_DELETEORPHANVERTIC = 1235109;

function mR3SUBDIVM_DELETEORPHANVERTIC() {
  DoA(this.r3obj, 1235109, 0, R3TID_INTEGER, 0);
}

// Description: Low level set point method. The point is given in object space.    * The method
//      doesn't generate R3MM_CHANGED nor call R3TTM_CHANGENIMATEDTAG.
// Returns: Boolean, true if succeeded
// p1: Integer, index
// p3: r3Vect, point

R3SUBDIVM_SETPOINTLOCAL = 1235110;

function mR3SUBDIVM_SETPOINTLOCAL(p1, p3) {
  return   DoA2(this.r3obj, 1235110, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Get point in object space
// Returns: Boolean, true if succeeded
// p1: Integer, index
// p3: r3Vect, point

R3SUBDIVM_GETPOINTLOCAL = 1235111;

function mR3SUBDIVM_GETPOINTLOCAL(p1, p3) {
  return   DoA2(this.r3obj, 1235111, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Returns next unique face id
// Returns: Integer, face id

R3SUBDIVM_ALLOCFACEID = 1235112;

function mR3SUBDIVM_ALLOCFACEID() {
  return   DoA(this.r3obj, 1235112, 0, R3TID_INTEGER, 0);
}

// Description: Registers an object that will be notified when certain events occur
// p2: Integer, event flags, see registernotify_flags below
// p3: Integer, method to notify with

R3SUBDIVM_REGISTERNOTIFY = 1235115;

function mR3SUBDIVM_REGISTERNOTIFY(p2, p3) {
  DoA3(this.r3obj, 1235115, 0, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Unregisters a notify object

R3SUBDIVM_UNREGISTERNOTIFY = 1235116;

function mR3SUBDIVM_UNREGISTERNOTIFY() {
  DoA(this.r3obj, 1235116, 0, R3TID_INTEGER, 0);
}

// Description: Unwraps the geometry using the subdivision algorithm.
// p3: Integer, subdivision iterations

R3SUBDIVM_UNWRAPGEOMETRY = 1235118;

function mR3SUBDIVM_UNWRAPGEOMETRY(p3) {
  DoA(this.r3obj, 1235118, p3, R3TID_INTEGER, 0);
}

// Description: Get face center and normal in object space.
// p1: Integer, face index
// p2: r3Vect, face center
// p3: r3Vect, face normal

R3SUBDIVM_GETFACECENTERANDNO = 1235122;

function mR3SUBDIVM_GETFACECENTERANDNO(p1, p2, p3) {
  DoA3(this.r3obj, 1235122, p1, R3TID_INTEGER, 0, p2, R3TID_VECTOR, 0, p3, R3TID_VECTOR, 0);
}

// p3: String, face material name

R3SUBDIVM_AUTOINITIALIZEFACE = 1235123;

function mR3SUBDIVM_AUTOINITIALIZEFACE(p3) {
  DoA(this.r3obj, 1235123, p3, R3TID_STRING, 0);
}

// p1: String, old face material name
// p3: String, new face material name

R3SUBDIVM_RENAMEFACEMATERIAL = 1235125;

function mR3SUBDIVM_RENAMEFACEMATERIAL(p1, p3) {
  DoA2(this.r3obj, 1235125, p1, R3TID_STRING, 0, p3, R3TID_STRING, 0);
}

// Description: return the maximum number of edges connecting to a vertex.
// Returns: Integer, max connecting edge count

R3SUBDIVM_GETMAXEDGESPERVERT = 1235126;

function mR3SUBDIVM_GETMAXEDGESPERVERT() {
  return   DoA(this.r3obj, 1235126, 0, R3TID_INTEGER, 0);
}

// Description: Divides the selected faces to triangles using triangulation algorithm.
// Returns: Boolean, TRUE if successfull
// p1: Boolean, if TRUE excludes quad faces
// p3: Boolean, if TRUE processes all faces (not only selected) except quads if p1 is TRUE

R3SUBDIVM_SELECTEDFACESTOTRI = 1235127;

function mR3SUBDIVM_SELECTEDFACESTOTRI(p1, p3) {
  return   DoA2(this.r3obj, 1235127, p1, R3TID_BOOLEAN, 0, p3, R3TID_BOOLEAN, 0);
}

// Description: Welds two (selected) edge loops together by adding new faces into the gap
// Returns: Boolean, TRUE if successfull

R3SUBDIVM_WELD = 1235128;

function mR3SUBDIVM_WELD() {
  return   DoA(this.r3obj, 1235128, 0, R3TID_INTEGER, 0);
}

// Description: Fetch face indices of given face.
// Returns: Integer, number of vertices in the face or NULL if the face was not found
// p1: Integer, index of the face
// p3: Integer[], memory buffer for the faces indices to be fetched. Use R3SUBDIVM_GETVERTEXCOUNTOFFACE    * method to fetch
//      the size for the buffer.

R3SUBDIVM_GETFACE = 1235129;

function mR3SUBDIVM_GETFACE(p1, p3) {
  return   DoA2(this.r3obj, 1235129, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Flattens selected regions.
// Returns: Boolean, TRUE if successfull

R3SUBDIVM_FLATTEN = 1235130;

function mR3SUBDIVM_FLATTEN() {
  return   DoA(this.r3obj, 1235130, 0, R3TID_INTEGER, 0);
}

// Description: Sets point/edge creates by a threshold angle. Does not change already set creases. In
//      edit mode, obeys selection areas.
// Returns: Boolean, TRUE if successfull
// p1: Integer, flagbit1=1 -> set edge creases, flagbit2=2 -> set point creases. E.g. 3 = set
//      both crease types.
// p3: Number, angle in radians

R3SUBDIVM_AUTOCREASES = 1235131;

function mR3SUBDIVM_AUTOCREASES(p1, p3) {
  return   DoA2(this.r3obj, 1235131, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Fetch the vertex index of give face point.
// Returns: Integer, vertex index, or -1 if given face point was not found.
// p1: Integer, face index
// p3: Integer, face point

R3SUBDIVM_GETFACEINDEX = 1235132;

function mR3SUBDIVM_GETFACEINDEX(p1, p3) {
  return   DoA2(this.r3obj, 1235132, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}




R3SUBDIVA_PointCount = 1235500;
function SetR3SUBDIVA_PointCount(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointCount, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_PointCount() {
  return R3Get(this.r3obj, R3SUBDIVA_PointCount, R3TID_INTEGER, 0);
}

R3SUBDIVA_Points = 1235501;
function SetR3SUBDIVA_Points(value) {
  R3Set(this.r3obj, R3SUBDIVA_Points, value, R3TID_VECTOR, R3TNF_ARRAY);
}

function GetR3SUBDIVA_Points() {
  return R3Get(this.r3obj, R3SUBDIVA_Points, R3TID_VECTOR, R3TNF_ARRAY);
}

R3SUBDIVA_FaceCount = 1235502;
function SetR3SUBDIVA_FaceCount(value) {
  R3Set(this.r3obj, R3SUBDIVA_FaceCount, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_FaceCount() {
  return R3Get(this.r3obj, R3SUBDIVA_FaceCount, R3TID_INTEGER, 0);
}

R3SUBDIVA_Type = 1235504;
function SetR3SUBDIVA_Type(value) {
  R3Set(this.r3obj, R3SUBDIVA_Type, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_Type() {
  return R3Get(this.r3obj, R3SUBDIVA_Type, R3TID_INTEGER, 0);
}

R3SUBDIVA_SelectResolution = 1235505;
function SetR3SUBDIVA_SelectResolution(value) {
  R3Set(this.r3obj, R3SUBDIVA_SelectResolution, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_SelectResolution() {
  return R3Get(this.r3obj, R3SUBDIVA_SelectResolution, R3TID_INTEGER, 0);
}

R3SUBDIVA_EdgeCount = 1235509;
function GetR3SUBDIVA_EdgeCount() {
  return R3Get(this.r3obj, R3SUBDIVA_EdgeCount, R3TID_INTEGER, 0);
}

R3SUBDIVA_UVCoords = 1235510;
function SetR3SUBDIVA_UVCoords(value) {
  R3Set(this.r3obj, R3SUBDIVA_UVCoords, value, R3TID_VECTOR, R3TNF_ARRAY);
}

function GetR3SUBDIVA_UVCoords() {
  return R3Get(this.r3obj, R3SUBDIVA_UVCoords, R3TID_VECTOR, R3TNF_ARRAY);
}

R3SUBDIVA_Quality = 1235511;
function SetR3SUBDIVA_Quality(value) {
  R3Set(this.r3obj, R3SUBDIVA_Quality, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_Quality() {
  return R3Get(this.r3obj, R3SUBDIVA_Quality, R3TID_INTEGER, 0);
}

R3SUBDIVA_CurrentUVName = 1235518;
function SetR3SUBDIVA_CurrentUVName(value) {
  R3Set(this.r3obj, R3SUBDIVA_CurrentUVName, value, R3TID_STRING, 0);
}

function GetR3SUBDIVA_CurrentUVName() {
  return R3Get(this.r3obj, R3SUBDIVA_CurrentUVName, R3TID_STRING, 0);
}

R3SUBDIVA_WrapU = 1235519;
function SetR3SUBDIVA_WrapU(value) {
  R3Set(this.r3obj, R3SUBDIVA_WrapU, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_WrapU() {
  return R3Get(this.r3obj, R3SUBDIVA_WrapU, R3TID_INTEGER, 0);
}

R3SUBDIVA_WrapV = 1235520;
function SetR3SUBDIVA_WrapV(value) {
  R3Set(this.r3obj, R3SUBDIVA_WrapV, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_WrapV() {
  return R3Get(this.r3obj, R3SUBDIVA_WrapV, R3TID_INTEGER, 0);
}

var R3SUBDIVA_ExtrudeSectionCount = 1235524; // Integer
var R3SUBDIVA_TransformCenter = 1235525; // r3Vect[]
var R3SUBDIVA_TransformNormal = 1235526; // r3Vect[]
var R3SUBDIVA_PointwiseChannel = 1235529; // Integer
var R3SUBDIVA_PointwiseID = 1235530; // Integer
var R3SUBDIVA_PointwiseName = 1235531; // String
var R3SUBDIVA_HasPointwiseColors = 1235532; // Boolean
R3SUBDIVA_Weights = 1235533;
function SetR3SUBDIVA_Weights(value) {
  R3Set(this.r3obj, R3SUBDIVA_Weights, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_Weights() {
  return R3Get(this.r3obj, R3SUBDIVA_Weights, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_FloatSize = 1235534;
function GetR3SUBDIVA_FloatSize() {
  return R3Get(this.r3obj, R3SUBDIVA_FloatSize, R3TID_INTEGER, 0);
}

R3SUBDIVA_ColorSize = 1235535;
function GetR3SUBDIVA_ColorSize() {
  return R3Get(this.r3obj, R3SUBDIVA_ColorSize, R3TID_INTEGER, 0);
}

R3SUBDIVA_PointwiseColor = 1235536;
function SetR3SUBDIVA_PointwiseColor(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseColor, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseColor() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseColor, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseTranspare = 1235537;
function SetR3SUBDIVA_PointwiseTranspare(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseTranspare, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseTranspare() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseTranspare, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseReflectio = 1235538;
function SetR3SUBDIVA_PointwiseReflectio(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseReflectio, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseReflectio() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseReflectio, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseAlpha = 1235539;
function SetR3SUBDIVA_PointwiseAlpha(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseAlpha, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseAlpha() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseAlpha, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseFade = 1235540;
function SetR3SUBDIVA_PointwiseFade(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseFade, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseFade() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseFade, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseIlluminat = 1235541;
function SetR3SUBDIVA_PointwiseIlluminat(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseIlluminat, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseIlluminat() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseIlluminat, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseMatSpaceC = 1235542;
function SetR3SUBDIVA_PointwiseMatSpaceC(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseMatSpaceC, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseMatSpaceC() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseMatSpaceC, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseOpticalTh = 1235543;
function SetR3SUBDIVA_PointwiseOpticalTh(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseOpticalTh, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseOpticalTh() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseOpticalTh, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseScope = 1235544;
function SetR3SUBDIVA_PointwiseScope(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseScope, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseScope() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseScope, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_PointwiseVolumeSam = 1235545;
function SetR3SUBDIVA_PointwiseVolumeSam(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseVolumeSam, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseVolumeSam() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseVolumeSam, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_InterpolateBoundar = 1235546;
function SetR3SUBDIVA_InterpolateBoundar(value) {
  R3Set(this.r3obj, R3SUBDIVA_InterpolateBoundar, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_InterpolateBoundar() {
  return R3Get(this.r3obj, R3SUBDIVA_InterpolateBoundar, R3TID_INTEGER, 0);
}

R3SUBDIVA_HasRoundings = 1235548;
function GetR3SUBDIVA_HasRoundings() {
  return R3Get(this.r3obj, R3SUBDIVA_HasRoundings, R3TID_INTEGER, 0);
}

var R3SUBDIVA_ScaleDirection = 1235549; // r3Vect[]
R3SUBDIVA_CurrentFaceMateria = 1235550;
function SetR3SUBDIVA_CurrentFaceMateria(value) {
  R3Set(this.r3obj, R3SUBDIVA_CurrentFaceMateria, value, R3TID_STRING, 0);
}

function GetR3SUBDIVA_CurrentFaceMateria() {
  return R3Get(this.r3obj, R3SUBDIVA_CurrentFaceMateria, R3TID_STRING, 0);
}

R3SUBDIVA_ChannelList = 1235551;
function GetR3SUBDIVA_ChannelList() {
  return R3Get(this.r3obj, R3SUBDIVA_ChannelList, R3TID_LIST, R3TNF_ARRAY);
}

var R3SUBDIVA_PointwiseData = 1235552; // Object
R3SUBDIVA_PointwiseUVCoords = 1235553;
function SetR3SUBDIVA_PointwiseUVCoords(value) {
  R3Set(this.r3obj, R3SUBDIVA_PointwiseUVCoords, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3SUBDIVA_PointwiseUVCoords() {
  return R3Get(this.r3obj, R3SUBDIVA_PointwiseUVCoords, R3TID_FLOAT, R3TNF_ARRAY);
}

R3SUBDIVA_SelectFaceVertices = 1235556;
function SetR3SUBDIVA_SelectFaceVertices(value) {
  R3Set(this.r3obj, R3SUBDIVA_SelectFaceVertices, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_SelectFaceVertices() {
  return R3Get(this.r3obj, R3SUBDIVA_SelectFaceVertices, R3TID_INTEGER, 0);
}

R3SUBDIVA_VertexUVsInFaceMod = 1235557;
function SetR3SUBDIVA_VertexUVsInFaceMod(value) {
  R3Set(this.r3obj, R3SUBDIVA_VertexUVsInFaceMod, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_VertexUVsInFaceMod() {
  return R3Get(this.r3obj, R3SUBDIVA_VertexUVsInFaceMod, R3TID_INTEGER, 0);
}

R3SUBDIVA_PhongShade = 1235581;
function SetR3SUBDIVA_PhongShade(value) {
  R3Set(this.r3obj, R3SUBDIVA_PhongShade, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_PhongShade() {
  return R3Get(this.r3obj, R3SUBDIVA_PhongShade, R3TID_INTEGER, 0);
}

R3SUBDIVA_MaxDisplacement = 1235582;
function SetR3SUBDIVA_MaxDisplacement(value) {
  R3Set(this.r3obj, R3SUBDIVA_MaxDisplacement, value, R3TID_FLOAT, 0);
}

function GetR3SUBDIVA_MaxDisplacement() {
  return R3Get(this.r3obj, R3SUBDIVA_MaxDisplacement, R3TID_FLOAT, 0);
}

var R3SUBDIVA_EvalDenseParamAddr = 1235583; // r3Vect[]
var R3SUBDIVA_EvalDenseFaceMaterial = 1235584; // String
R3SUBDIVA_NextFaceId = 1235585;
function SetR3SUBDIVA_NextFaceId(value) {
  R3Set(this.r3obj, R3SUBDIVA_NextFaceId, value, R3TID_INTEGER, 0);
}

function GetR3SUBDIVA_NextFaceId() {
  return R3Get(this.r3obj, R3SUBDIVA_NextFaceId, R3TID_INTEGER, 0);
}

var R3SUBDIVA_NoAutoUVInit = 1235586; // Boolean
var R3SUBDIVA_KeepAllPoints = 1235587; // Boolean
var R3SUBDIVHT_VERTEX = 0;
var R3SUBDIVHT_EDGE = 1;
var R3SUBDIVHT_FACE = 2;
var R3SUBDIVHT_CENTER = 3;
var R3SUBDIVHT_FACEVERTEX = 4;
var R3SUBDIVR_POINT = 0;
var R3SUBDIVR_EDGE = 1;
var R3SUBDIVR_FACE = 2;
var R3SUBDIVEXTRREGIONOPT_GROUPS = 0;
var R3SUBDIVEXTRREGIONOPT_SEPARATE = 1;
var R3SUBDIVEXTRNORMALOPT_GROUP = 0;
var R3SUBDIVEXTRNORMALOPT_FACE = 1;
var R3SUBDIVEXTRNORMALOPT_VERTEX = 2;
var R3SUBDIVEXTRNORMALOPT_SELECTEDFACEVERTEX = 3;
var R3SUBDIVACTION_EXTRUDE = 0;
var R3SUBDIVACTION_SUBDIVIDE = 1;
var R3SUBDIVTYPE_SMOOTH = 0;
var R3SUBDIVTYPE_SMOOTHBILINEAR = 1;
var R3SUBDIVTYPE_SMOOTHTRIANGLE = 2;
var R3SUBDIVTYPE_POLYGONAL = 3;
var R3SDSTRANSFFACENORMALOPT_FACE = 0;
var R3SDSTRANSFFACENORMALOPT_GROUP = 1;
var R3SDSVERTEXSHARPNESS_ROUNDED = 0;
var R3SDSVERTEXSHARPNESS_SEMISHARP = 1;
var R3SDSVERTEXSHARPNESS_SHARP = 2;
var R3SDSEDGESHARPNESS_ROUNDED = 0;
var R3SDSEDGESHARPNESS_SEMISHARP = 1;
var R3SDSEDGESHARPNESS_SHARP = 2;
var R3SDSEDGESHARPNESS_FREE = 3;
var R3MAX_PWCOMPONETS = 3;
var R3SDSFACEMATERIALF_TEXTURE = 1;
var R3SDSNOTIFY_REMOVEFACE = 1;
var R3SDSNOTIFY_INVALIDATEFACEID = 2;
var R3SDSNOTIFY_BEVELEDOBJECT = 4;
var R3SDSNOTIFY_BEGINCHANGEFACEID = 8;
var R3SDSNOTIFY_CHANGEFACEID = 16;
var R3SDSNOTIFY_ENDCHANGEFACEID = 32;
include("real/raytr/r3cmetnu.js")


function r3Subdivision () {
   this.base = r3God;
   if(arguments.length) {
      this.base(R3CLID_SUBDIVISION, arguments);
   }
   // Methods
   this.ADDFACE=mR3SUBDIVM_ADDFACE;
   this.MERGEVERTICES=mR3SUBDIVM_MERGEVERTICES;
   this.SUBDIVIDE=mR3SUBDIVM_SUBDIVIDE;
   this.SUBDIVIDEFACE=mR3SUBDIVM_SUBDIVIDEFACE;
   this.EXTRUDE=mR3SUBDIVM_EXTRUDE;
   this.GETMAXEDGESPERFACE=mR3SUBDIVM_GETMAXEDGESPERFACE;
   this.SPLITEDGE=mR3SUBDIVM_SPLITEDGE;
   this.DIVIDEFACE=mR3SUBDIVM_DIVIDEFACE;
   this.MERGEFACES=mR3SUBDIVM_MERGEFACES;
   this.SETUV=mR3SUBDIVM_SETUV;
   this.GETUV=mR3SUBDIVM_GETUV;
   this.SEPARATEFACES=mR3SUBDIVM_SEPARATEFACES;
   this.NEWFACE=mR3SUBDIVM_NEWFACE;
   this.DELFACE=mR3SUBDIVM_DELFACE;
   this.UPDATEFACE=mR3SUBDIVM_UPDATEFACE;
   this.MELT=mR3SUBDIVM_MELT;
   this.EXTRUDEVERTEX=mR3SUBDIVM_EXTRUDEVERTEX;
   this.MERGEOBJECTS=mR3SUBDIVM_MERGEOBJECTS;
   this.HIDESELECTEDFACES=mR3SUBDIVM_HIDESELECTEDFACES;
   this.SHOWALLFACES=mR3SUBDIVM_SHOWALLFACES;
   this.CONNECTEDGES=mR3SUBDIVM_CONNECTEDGES;
   this.TRANSFORMFACE=mR3SUBDIVM_TRANSFORMFACE;
   this.DUPLICATEANDCONNEC=mR3SUBDIVM_DUPLICATEANDCONNEC;
   this.BEVELVERTICES=mR3SUBDIVM_BEVELVERTICES;
   this.BEVELEDGES=mR3SUBDIVM_BEVELEDGES;
   this.FACETOTRISETS=mR3SUBDIVCM_FACETOTRISETS;
   this.FLIPSELECTEDFACES=mR3SUBDIVM_FLIPSELECTEDFACES;
   this.ADDUVWCHANNEL=mR3SUBDIVM_ADDUVWCHANNEL;
   this.DELUVWCHANNEL=mR3SUBDIVM_DELUVWCHANNEL;
   this.MERGEEDGES=mR3SUBDIVM_MERGEEDGES;
   this.DESTROYFACE=mR3SUBDIVM_DESTROYFACE;
   this.MERGEOBJECTSSELECT=mR3SUBDIVM_MERGEOBJECTSSELECT;
   this.POLYGONALTOTRISETS=mR3SUBDIVM_POLYGONALTOTRISETS;
   this.SMOOTHTOTRISETS=mR3SUBDIVM_SMOOTHTOTRISETS;
   this.SELECTEDFACESTOTRI=mR3SUBDIVM_SELECTEDFACESTOTRI;
   this.SELECTEDFACESTOQUA=mR3SUBDIVM_SELECTEDFACESTOQUA;
   this.FACESCHANGEDFROMOU=mR3SUBDIVM_FACESCHANGEDFROMOU;
   this.MAKETUNNEL=mR3SUBDIVM_MAKETUNNEL;
   this.SUBDIVIDELOCALLY=mR3SUBDIVM_SUBDIVIDELOCALLY;
   this.CALCULATEVERTEXNOR=mR3SUBDIVM_CALCULATEVERTEXNOR;
   this.MOVEVERTEXONNORMAL=mR3SUBDIVM_MOVEVERTEXONNORMAL;
   this.INVALIDATESMOOTHOB=mR3SUBDIVM_INVALIDATESMOOTHOB;
   this.CALCULATEEDGECENTE=mR3SUBDIVM_CALCULATEEDGECENTE;
   this.TRANSFORMEDGE=mR3SUBDIVM_TRANSFORMEDGE;
   this.SELECTINVALIDFACES=mR3SUBDIVM_SELECTINVALIDFACES;
   this.SMOOTHENVERTEXNORM=mR3SUBDIVM_SMOOTHENVERTEXNORM;
   this.FLATTENVERTEXNORMA=mR3SUBDIVM_FLATTENVERTEXNORMA;
   this.SETPOINTWISEVALUE=mR3SUBDIVM_SETPOINTWISEVALUE;
   this.GETPOINTWISEVALUE=mR3SUBDIVM_GETPOINTWISEVALUE;
   this.ADDPOINTWISEATTRIB=mR3SUBDIVM_ADDPOINTWISEATTRIB;
   this.REMOVEPOINTWISEATT=mR3SUBDIVM_REMOVEPOINTWISEATT;
   this.GETWEIGHTS=mR3SUBDIVM_GETWEIGHTS;
   this.CHANGEWEIGHTS=mR3SUBDIVM_CHANGEWEIGHTS;
   this.TRIANGLESTOQUADS=mR3SUBDIVM_TRIANGLESTOQUADS;
   this.INVERT=mR3SUBDIVM_INVERT;
   this.RENDERPATCHES=mR3SUBDIVM_RENDERPATCHES;
   this.SETSELECTEDEDGESHA=mR3SUBDIVM_SETSELECTEDEDGESHA;
   this.GETEDGESHARPNESS=mR3SUBDIVM_GETEDGESHARPNESS;
   this.SETSELECTEDVERTEXS=mR3SUBDIVM_SETSELECTEDVERTEXS;
   this.GETVERTEXSHARPNESS=mR3SUBDIVM_GETVERTEXSHARPNESS;
   this.FREEEDGELIST=mR3SUBDIVM_FREEEDGELIST;
   this.SETSELECTEDEDGEROU=mR3SUBDIVM_SETSELECTEDEDGEROU;
   this.GETEDGEROUNDING=mR3SUBDIVM_GETEDGEROUNDING;
   this.JOINFACES=mR3SUBDIVM_JOINFACES;
   this.GETPOINTWISECHANNE=mR3SUBDIVM_GETPOINTWISECHANNE;
   this.GETFACESPACE=mR3SUBDIVM_GETFACESPACE;
   this.GETUVWATTRS=mR3SUBDIVM_GETUVWATTRS;
   this.GETCHANNELATTRS=mR3SUBDIVM_GETCHANNELATTRS;
   this.ALLOCPOINTS=mR3SUBDIVM_ALLOCPOINTS;
   this.ASSIGNVERTEX=mR3SUBDIVM_ASSIGNVERTEX;
   this.MAKEFACE=mR3SUBDIVM_MAKEFACE;
   this.ATTACHMATERIALTOSE=mR3SUBDIVM_ATTACHMATERIALTOSE;
   this.DETACHMATERIALFROM=mR3SUBDIVM_DETACHMATERIALFROM;
   this.GETFACEMATERIALLIS=mR3SUBDIVM_GETFACEMATERIALLIS;
   this.OPTIMIZEFACES=mR3SUBDIVM_OPTIMIZEFACES;
   this.INSERTVERTEXTOFACE=mR3SUBDIVM_INSERTVERTEXTOFACE;
   this.REMOVEVERTEXFROMFA=mR3SUBDIVM_REMOVEVERTEXFROMFA;
   this.SETSELECTEDFACESUV=mR3SUBDIVM_SETSELECTEDFACESUV;
   this.SETALLFACESUVVISIB=mR3SUBDIVM_SETALLFACESUVVISIB;
   this.SETFACEMATERIALUV=mR3SUBDIVM_SETFACEMATERIALUV;
   this.DETACHMATERIALFROM=mR3SUBDIVM_DETACHMATERIALFROM;
   this.GETVERTEXCOUNTOFFA=mR3SUBDIVM_GETVERTEXCOUNTOFFA;
   this.INTERPOLATEPOINTWI=mR3SUBDIVM_INTERPOLATEPOINTWI;
   this.DIVIDEFACESBYINDIC=mR3SUBDIVM_DIVIDEFACESBYINDIC;
   this.CALCULATEFACECENTE=mR3SUBDIVM_CALCULATEFACECENTE;
   this.DUPLICATE=mR3SUBDIVM_DUPLICATE;
   this.COPYSELECTED=mR3SUBDIVM_COPYSELECTED;
   this.SETFACE=mR3SUBDIVM_SETFACE;
   this.FILLHOLES=mR3SUBDIVM_FILLHOLES;
   this.UNWRAPUV=mR3SUBDIVM_UNWRAPUV;
   this.DEFAULTUV=mR3SUBDIVM_DEFAULTUV;
   this.DELETEORPHANVERTIC=mR3SUBDIVM_DELETEORPHANVERTIC;
   this.SETPOINTLOCAL=mR3SUBDIVM_SETPOINTLOCAL;
   this.GETPOINTLOCAL=mR3SUBDIVM_GETPOINTLOCAL;
   this.ALLOCFACEID=mR3SUBDIVM_ALLOCFACEID;
   this.REGISTERNOTIFY=mR3SUBDIVM_REGISTERNOTIFY;
   this.UNREGISTERNOTIFY=mR3SUBDIVM_UNREGISTERNOTIFY;
   this.UNWRAPGEOMETRY=mR3SUBDIVM_UNWRAPGEOMETRY;
   this.GETFACECENTERANDNO=mR3SUBDIVM_GETFACECENTERANDNO;
   this.AUTOINITIALIZEFACE=mR3SUBDIVM_AUTOINITIALIZEFACE;
   this.RENAMEFACEMATERIAL=mR3SUBDIVM_RENAMEFACEMATERIAL;
   this.GETMAXEDGESPERVERT=mR3SUBDIVM_GETMAXEDGESPERVERT;
   this.SELECTEDFACESTOTRI=mR3SUBDIVM_SELECTEDFACESTOTRI;
   this.WELD=mR3SUBDIVM_WELD;
   this.GETFACE=mR3SUBDIVM_GETFACE;
   this.FLATTEN=mR3SUBDIVM_FLATTEN;
   this.AUTOCREASES=mR3SUBDIVM_AUTOCREASES;
   this.GETFACEINDEX=mR3SUBDIVM_GETFACEINDEX;

   // Attributes
   this.GetPointCount=GetR3SUBDIVA_PointCount;
   this.SetPointCount=SetR3SUBDIVA_PointCount;
   this.GetPoints=GetR3SUBDIVA_Points;
   this.SetPoints=SetR3SUBDIVA_Points;
   this.GetFaceCount=GetR3SUBDIVA_FaceCount;
   this.SetFaceCount=SetR3SUBDIVA_FaceCount;
   this.GetType=GetR3SUBDIVA_Type;
   this.SetType=SetR3SUBDIVA_Type;
   this.GetSelectResolution=GetR3SUBDIVA_SelectResolution;
   this.SetSelectResolution=SetR3SUBDIVA_SelectResolution;
   this.GetEdgeCount=GetR3SUBDIVA_EdgeCount;
   this.GetUVCoords=GetR3SUBDIVA_UVCoords;
   this.SetUVCoords=SetR3SUBDIVA_UVCoords;
   this.GetQuality=GetR3SUBDIVA_Quality;
   this.SetQuality=SetR3SUBDIVA_Quality;
   this.GetCurrentUVName=GetR3SUBDIVA_CurrentUVName;
   this.SetCurrentUVName=SetR3SUBDIVA_CurrentUVName;
   this.GetWrapU=GetR3SUBDIVA_WrapU;
   this.SetWrapU=SetR3SUBDIVA_WrapU;
   this.GetWrapV=GetR3SUBDIVA_WrapV;
   this.SetWrapV=SetR3SUBDIVA_WrapV;
   this.GetWeights=GetR3SUBDIVA_Weights;
   this.SetWeights=SetR3SUBDIVA_Weights;
   this.GetFloatSize=GetR3SUBDIVA_FloatSize;
   this.GetColorSize=GetR3SUBDIVA_ColorSize;
   this.GetPointwiseColor=GetR3SUBDIVA_PointwiseColor;
   this.SetPointwiseColor=SetR3SUBDIVA_PointwiseColor;
   this.GetPointwiseTranspare=GetR3SUBDIVA_PointwiseTranspare;
   this.SetPointwiseTranspare=SetR3SUBDIVA_PointwiseTranspare;
   this.GetPointwiseReflectio=GetR3SUBDIVA_PointwiseReflectio;
   this.SetPointwiseReflectio=SetR3SUBDIVA_PointwiseReflectio;
   this.GetPointwiseAlpha=GetR3SUBDIVA_PointwiseAlpha;
   this.SetPointwiseAlpha=SetR3SUBDIVA_PointwiseAlpha;
   this.GetPointwiseFade=GetR3SUBDIVA_PointwiseFade;
   this.SetPointwiseFade=SetR3SUBDIVA_PointwiseFade;
   this.GetPointwiseIlluminat=GetR3SUBDIVA_PointwiseIlluminat;
   this.SetPointwiseIlluminat=SetR3SUBDIVA_PointwiseIlluminat;
   this.GetPointwiseMatSpaceC=GetR3SUBDIVA_PointwiseMatSpaceC;
   this.SetPointwiseMatSpaceC=SetR3SUBDIVA_PointwiseMatSpaceC;
   this.GetPointwiseOpticalTh=GetR3SUBDIVA_PointwiseOpticalTh;
   this.SetPointwiseOpticalTh=SetR3SUBDIVA_PointwiseOpticalTh;
   this.GetPointwiseScope=GetR3SUBDIVA_PointwiseScope;
   this.SetPointwiseScope=SetR3SUBDIVA_PointwiseScope;
   this.GetPointwiseVolumeSam=GetR3SUBDIVA_PointwiseVolumeSam;
   this.SetPointwiseVolumeSam=SetR3SUBDIVA_PointwiseVolumeSam;
   this.GetInterpolateBoundar=GetR3SUBDIVA_InterpolateBoundar;
   this.SetInterpolateBoundar=SetR3SUBDIVA_InterpolateBoundar;
   this.GetHasRoundings=GetR3SUBDIVA_HasRoundings;
   this.GetCurrentFaceMateria=GetR3SUBDIVA_CurrentFaceMateria;
   this.SetCurrentFaceMateria=SetR3SUBDIVA_CurrentFaceMateria;
   this.GetChannelList=GetR3SUBDIVA_ChannelList;
   this.GetPointwiseUVCoords=GetR3SUBDIVA_PointwiseUVCoords;
   this.SetPointwiseUVCoords=SetR3SUBDIVA_PointwiseUVCoords;
   this.GetSelectFaceVertices=GetR3SUBDIVA_SelectFaceVertices;
   this.SetSelectFaceVertices=SetR3SUBDIVA_SelectFaceVertices;
   this.GetVertexUVsInFaceMod=GetR3SUBDIVA_VertexUVsInFaceMod;
   this.SetVertexUVsInFaceMod=SetR3SUBDIVA_VertexUVsInFaceMod;
   this.GetPhongShade=GetR3SUBDIVA_PhongShade;
   this.SetPhongShade=SetR3SUBDIVA_PhongShade;
   this.GetMaxDisplacement=GetR3SUBDIVA_MaxDisplacement;
   this.SetMaxDisplacement=SetR3SUBDIVA_MaxDisplacement;
   this.GetNextFaceId=GetR3SUBDIVA_NextFaceId;
   this.SetNextFaceId=SetR3SUBDIVA_NextFaceId;
}

r3Subdivision.prototype=new r3Level;
// r3subdiv.h_H